{
 "cells": [
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Fourier Neural Operator 1D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "c:\\Users\\s1612415\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\tqdm\\auto.py:22: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "## Imports \n",
    "import matplotlib.pyplot as plt \n",
    "import numpy as np \n",
    "import torch \n",
    "import torch.nn as nn\n",
    "from timeit import default_timer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Set seeds\n",
    "torch.manual_seed(0)\n",
    "np.random.seed(0)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Create Data"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Ordinary Differential Equation:\n",
    "\n",
    "\\begin{align*}\n",
    "m\\frac{d^2x}{dt^2} = - kx\n",
    "\\end{align*}\n",
    "\n",
    "Solution: \n",
    "$$x(t) = x_0 \\cos{\\left(\\sqrt{\\frac{k}{m}}t\\right)} + \\frac{v_0}{\\sqrt{\\frac{k}{m}}}\\sin{\\left(\\sqrt{\\frac{k}{m}}t\\right)}$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "## TODO: Create Simple Harmonic Oscillator Class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Simple Harmonic Oscillator\n",
    "def simple_harmonic_oscillator(k: int, m: int, x0: int, v0: int, t: np.array) -> np.array:\n",
    "    x = x0 * np.cos(np.sqrt(k / m) * t) + (v0 / np.sqrt(k / m)) * np.sin(np.sqrt(k / m) * t)\n",
    "    return x    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Number of Samples \n",
    "n = 1000\n",
    "## Output\n",
    "data_t = []\n",
    "data_x = []\n",
    "\n",
    "# k = np.random.randint(1, 100)\n",
    "# m = np.random.randint(1, 100)\n",
    "# x0 = np.random.normal(0, 10)\n",
    "# v0 = np.random.normal(0, 10)\n",
    "# k = 1\n",
    "# m = 1000\n",
    "# x0 = 1\n",
    "# v0 = 1\n",
    "\n",
    "t = np.linspace(0, 100, 100)\n",
    "\n",
    "## Generate Data\n",
    "for _ in range(n):\n",
    "    k = np.random.randint(1, 10)\n",
    "    k_vec = k * np.ones(100)\n",
    "    m = np.random.randint(100, 1000)\n",
    "    m_vec = m * np.ones(100)\n",
    "    x0 = np.random.normal(0, 10)\n",
    "    x0_vec = x0 * np.ones(100)\n",
    "    v0 = np.random.normal(0, 1)\n",
    "    v0_vec = v0 * np.ones(100)\n",
    "    \n",
    "    data_t.append([k_vec, m_vec, x0_vec, v0_vec, t])\n",
    "    # data_x.append(simple_harmonic_oscillator(k, m, x0, v0, t))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Plot\n",
    "# plt.scatter(data_t, data_x, alpha=0.5)\n",
    "# plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\s1612415\\AppData\\Local\\Temp\\ipykernel_17684\\1240523911.py:1: UserWarning: Creating a tensor from a list of numpy.ndarrays is extremely slow. Please consider converting the list to a single numpy.ndarray with numpy.array() before converting to a tensor. (Triggered internally at ..\\torch\\csrc\\utils\\tensor_new.cpp:233.)\n",
      "  data_t = torch.tensor(data_t, requires_grad=True).float()\n"
     ]
    }
   ],
   "source": [
    "data_t = torch.tensor(data_t, requires_grad=True).float()\n",
    "# data_x = np.array(torch.tensor(data_x).float().unsqueeze(1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Data Loader\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import pandas as pd\n",
    "\n",
    "class CustomDataset(Dataset):\n",
    "    def __init__(self, t): # , x):\n",
    "        self.t = t\n",
    "        # self.x = x\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.t)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        return self.t[index] # , self.x[index]\n",
    "\n",
    "data = CustomDataset(data_t) # , data_x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[  6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,   6.0000,\n",
       "           6.0000,   6.0000],\n",
       "        [292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000, 292.0000,\n",
       "         292.0000, 292.0000],\n",
       "        [  9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,   9.7874,\n",
       "           9.7874,   9.7874],\n",
       "        [  2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,   2.2409,\n",
       "           2.2409,   2.2409],\n",
       "        [  0.0000,   1.0101,   2.0202,   3.0303,   4.0404,   5.0505,   6.0606,\n",
       "           7.0707,   8.0808,   9.0909,  10.1010,  11.1111,  12.1212,  13.1313,\n",
       "          14.1414,  15.1515,  16.1616,  17.1717,  18.1818,  19.1919,  20.2020,\n",
       "          21.2121,  22.2222,  23.2323,  24.2424,  25.2525,  26.2626,  27.2727,\n",
       "          28.2828,  29.2929,  30.3030,  31.3131,  32.3232,  33.3333,  34.3434,\n",
       "          35.3535,  36.3636,  37.3737,  38.3838,  39.3939,  40.4040,  41.4141,\n",
       "          42.4242,  43.4343,  44.4444,  45.4545,  46.4646,  47.4747,  48.4848,\n",
       "          49.4949,  50.5051,  51.5152,  52.5253,  53.5354,  54.5455,  55.5556,\n",
       "          56.5657,  57.5758,  58.5859,  59.5960,  60.6061,  61.6162,  62.6263,\n",
       "          63.6364,  64.6465,  65.6566,  66.6667,  67.6768,  68.6869,  69.6970,\n",
       "          70.7071,  71.7172,  72.7273,  73.7374,  74.7475,  75.7576,  76.7677,\n",
       "          77.7778,  78.7879,  79.7980,  80.8081,  81.8182,  82.8283,  83.8384,\n",
       "          84.8485,  85.8586,  86.8687,  87.8788,  88.8889,  89.8990,  90.9091,\n",
       "          91.9192,  92.9293,  93.9394,  94.9495,  95.9596,  96.9697,  97.9798,\n",
       "          98.9899, 100.0000]], grad_fn=<SelectBackward0>)"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([5, 100])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "data[0].shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "dataloader = DataLoader(data, batch_size=64, shuffle=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([64, 5, 100])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "next(iter(dataloader)).shape"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Build Network"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Using cpu device.\n"
     ]
    }
   ],
   "source": [
    "## Get Device for Training\n",
    "device = 'cuda' if torch.cuda.is_available() else 'cpu'\n",
    "print(f'Using {device} device.')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Fourier Integral Kernel 1D\n",
    "class FourierIntegralKernel1D(nn.Module):\n",
    "    def __init__(self, in_channels: int, out_channels: int, modes: int):\n",
    "        super(FourierIntegralKernel1D, self).__init__()\n",
    "        '''\n",
    "        '''\n",
    "        self.in_channels = in_channels\n",
    "        self.out_channels = out_channels \n",
    "        self.modes = modes \n",
    "        ## Set (random) weights for the linear transform\n",
    "        weights = torch.rand(self.modes, self.out_channels, self.in_channels, dtype=torch.cfloat) \n",
    "        self.weights = nn.Parameter(weights / (self.in_channels * self.out_channels)) ## Optional: Scale weights\n",
    "\n",
    "    def forward(self, v: torch.Tensor) -> torch.Tensor:\n",
    "        '''\n",
    "        FFT -> Linear Transform -> Inverse FFT\n",
    "        '''\n",
    "        ## FFT\n",
    "        v_rfft = torch.fft.rfft(v) \n",
    "\n",
    "        ## Linear Transform \n",
    "        lv_rfft = torch.zeros(v_rfft.shape, dtype=torch.cfloat)\n",
    "        lv_rfft[:, :, :self.modes] = torch.einsum('koi, bki -> bko', self.weights, v_rfft[:, :, :self.modes].permute(0, 2, 1)).permute(0, 2, 1) ## TODO: Should I have 5 dimensions here?\n",
    "        \n",
    "        ## Inverse FFT\n",
    "        v2 = torch.fft.irfft(lv_rfft, n=v.shape[-1])\n",
    "        return v2\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Fourier Network Operator 1D\n",
    "class FourierNetworkOperator1D(nn.Module):\n",
    "    def __init__(self, da: int, du: int, width: int, modes: int):\n",
    "        super(FourierNetworkOperator1D, self).__init__()\n",
    "        '''\n",
    "        '''\n",
    "        self.width = width\n",
    "        self.modes = modes\n",
    "\n",
    "        ## P: Lifts the lower dimensional function to higher dimensional space\n",
    "        self.P = nn.Conv1d(da, self.width, 1) ## TODO: Change da\n",
    "\n",
    "        ## K: Fourier integral kernel operator\n",
    "        self.k0 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k1 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k2 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k3 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k4 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k5 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k6 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k7 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k8 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "        self.k9 = FourierIntegralKernel1D(self.width, self.width, self.modes)\n",
    "\n",
    "        ## W: Pointwise linear operator\n",
    "        self.w0 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w1 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w2 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w3 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w4 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w5 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w6 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w7 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w8 = nn.Conv1d(self.width, self.width, 1)\n",
    "        self.w9 = nn.Conv1d(self.width, self.width, 1)\n",
    "\n",
    "        ## Q: Projects the higher dimensional function to lower dimensional space\n",
    "        self.Q = nn.Conv1d(self.width, du, 1) ## TODO: Change du\n",
    "\n",
    "    def forward(self, x: torch.Tensor) -> torch.Tensor:\n",
    "        '''\n",
    "        '''\n",
    "        ## P\n",
    "        x = self.P(x)\n",
    "\n",
    "        ## Fourier Layer #0\n",
    "        ## K\n",
    "        x1 = self.k0(x)\n",
    "        ## W\n",
    "        x2 = self.w0(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #1\n",
    "        ## K\n",
    "        x1 = self.k1(x)\n",
    "        ## W\n",
    "        x2 = self.w1(x)\n",
    "        ## Sum \n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #2\n",
    "        ## K\n",
    "        x1 = self.k2(x)\n",
    "        ## W\n",
    "        x2 = self.w2(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #3\n",
    "        ## K\n",
    "        x1 = self.k3(x)\n",
    "        ## W\n",
    "        x2 = self.w3(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #4\n",
    "        ## K\n",
    "        x1 = self.k4(x)\n",
    "        ## W\n",
    "        x2 = self.w4(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #5\n",
    "        ## K\n",
    "        x1 = self.k5(x)\n",
    "        ## W\n",
    "        x2 = self.w5(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #6\n",
    "        ## K\n",
    "        x1 = self.k6(x)\n",
    "        ## W\n",
    "        x2 = self.w6(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #7\n",
    "        ## K\n",
    "        x1 = self.k7(x)\n",
    "        ## W\n",
    "        x2 = self.w7(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #8\n",
    "        ## K\n",
    "        x1 = self.k8(x)\n",
    "        ## W\n",
    "        x2 = self.w8(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Fourier Layer #9\n",
    "        ## K\n",
    "        x1 = self.k9(x)\n",
    "        ## W\n",
    "        x2 = self.w9(x)\n",
    "        ## Sum\n",
    "        x = x1 + x2\n",
    "        ## Gelu\n",
    "        x = nn.functional.gelu(x)\n",
    "        # x = nn.functional.gelu(x1)\n",
    "        # x = nn.functional.gelu(x2)\n",
    "\n",
    "        ## Q\n",
    "        x = self.Q(x)\n",
    "        return x\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Number of parameters: 697409\n"
     ]
    }
   ],
   "source": [
    "import operator\n",
    "from functools import reduce\n",
    "\n",
    "def count_parameters(model):\n",
    "    c = 0\n",
    "    for p in list(model.parameters()):\n",
    "        c += reduce(operator.mul, list(p.size() + (2, ) if p.is_complex() else p.size()))\n",
    "    return c\n",
    "\n",
    "model = FourierNetworkOperator1D(5, 1, width=64, modes=8)\n",
    "print(f'Number of parameters: {count_parameters(model)}')"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Train"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Model Parameters\n",
    "learning_rate = 1e-3\n",
    "epochs = 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "class PDELoss(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(PDELoss, self).__init__()\n",
    "\n",
    "    def forward(self, m, dxdt2, k, model_output):\n",
    "        return torch.mean(torch.mean(torch.square(m * dxdt2 + k * model_output.squeeze()), 1, keepdim=True), 0)\n",
    "\n",
    "loss_function = PDELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Loss Function\n",
    "# loss_function = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Optimizer \n",
    "optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k: 6\n",
      "m: 917\n",
      "x0: -5.888131995338436\n",
      "v0: -0.16615313560795222\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Test 0\n",
    "k0 = np.random.randint(1, 10)\n",
    "print(f'k: {k0}')\n",
    "k0_vec = torch.from_numpy(k0 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "m0 = np.random.randint(100, 1000)\n",
    "print(f'm: {m0}')\n",
    "m0_vec = torch.from_numpy(m0 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "x00 = np.random.normal(0, 10)\n",
    "print(f'x0: {x00}')\n",
    "x00_vec = torch.from_numpy(x00 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "v00 = np.random.normal(0, 1)\n",
    "print(f'v0: {v00}')\n",
    "v00_vec = torch.from_numpy(v00 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "t_test = torch.from_numpy(np.linspace(0, 100, 100)).float().unsqueeze(0).unsqueeze(0)\n",
    "x0_test = simple_harmonic_oscillator(k0, m0, x00, v00, t_test)\n",
    "\n",
    "\n",
    "plt.scatter(t_test, x0_test, alpha=0.5)\n",
    "plt.scatter(t_test, model(torch.cat((k0_vec, m0_vec, x00_vec, v00_vec, t_test), 1)).detach())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k: 2\n",
      "m: 953\n",
      "x0: -7.0665916119712735\n",
      "v0: -0.5844875170982337\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Test 1\n",
    "k1 = np.random.randint(1, 10)\n",
    "print(f'k: {k1}')\n",
    "k1_vec = torch.from_numpy(k1 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "m1 = np.random.randint(100, 1000)\n",
    "print(f'm: {m1}')\n",
    "m1_vec = torch.from_numpy(m1 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "x01 = np.random.normal(0, 10)\n",
    "print(f'x0: {x01}')\n",
    "x01_vec = torch.from_numpy(x01 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "v01 = np.random.normal(0, 1)\n",
    "print(f'v0: {v01}')\n",
    "v01_vec = torch.from_numpy(v01 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "t_test = torch.from_numpy(np.linspace(0, 100, 100)).float().unsqueeze(0).unsqueeze(0)\n",
    "x1_test = simple_harmonic_oscillator(k1, m1, x01, v01, t_test)\n",
    "\n",
    "\n",
    "plt.scatter(t_test, x1_test, alpha=0.5)\n",
    "plt.scatter(t_test, model(torch.cat((k1_vec, m1_vec, x01_vec, v01_vec, t_test), 1)).detach())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "k: 4\n",
      "m: 171\n",
      "x0: -3.3023789326454427\n",
      "v0: -0.8348071635345082\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Test 2\n",
    "k2 = np.random.randint(1, 10)\n",
    "print(f'k: {k2}')\n",
    "k2_vec = torch.from_numpy(k2 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "m2 = np.random.randint(100, 1000)\n",
    "print(f'm: {m2}')\n",
    "m2_vec = torch.from_numpy(m2 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "x02 = np.random.normal(0, 10)\n",
    "print(f'x0: {x02}')\n",
    "x02_vec = torch.from_numpy(x02 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "v02 = np.random.normal(0, 1)\n",
    "print(f'v0: {v02}')\n",
    "v02_vec = torch.from_numpy(v02 * np.ones(100)).float().unsqueeze(0).unsqueeze(0)\n",
    "\n",
    "t_test = torch.from_numpy(np.linspace(0, 100, 100)).float().unsqueeze(0).unsqueeze(0)\n",
    "x2_test = simple_harmonic_oscillator(k2, m2, x02, v02, t_test)\n",
    "\n",
    "\n",
    "plt.scatter(t_test, x2_test, alpha=0.5)\n",
    "plt.scatter(t_test, model(torch.cat((k2_vec, m2_vec, x02_vec, v02_vec, t_test), 1)).detach())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [],
   "source": [
    "## Training Loop\n",
    "def train_loop(dataloader, model, loss_function, optimizer):\n",
    "    size = len(dataloader.dataset)\n",
    "    for batch, t in enumerate(dataloader):\n",
    "        # Compute prediction and loss\n",
    "        pred = model(t)\n",
    "\n",
    "        m = t[:, 1, :]\n",
    "        k = t[:, 0, :]\n",
    "\n",
    "        dxdt1 = torch.autograd.grad(pred, t, retain_graph=True, create_graph=True, grad_outputs=torch.ones_like(pred))[0]\n",
    "        dxdt2  = torch.autograd.grad(dxdt1, t, grad_outputs=torch.ones_like(dxdt1))[0]\n",
    "        loss = loss_function(m, dxdt2[:, 4, :], k, pred)\n",
    "\n",
    "        # Backpropagation\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "\n",
    "        if batch % 100 == 0:\n",
    "            loss, current = loss.item(), batch * len(t)\n",
    "            print(f\"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1\n",
      "-------------------------------\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). Saved intermediate values of the graph are freed when you call .backward() or autograd.grad(). Specify retain_graph=True if you need to backward through the graph a second time or if you need to access saved tensors after calling backward.",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "Cell \u001b[1;32mIn [30], line 3\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[39mfor\u001b[39;00m t \u001b[39min\u001b[39;00m \u001b[39mrange\u001b[39m(epochs):\n\u001b[0;32m      2\u001b[0m     \u001b[39mprint\u001b[39m(\u001b[39mf\u001b[39m\u001b[39m\"\u001b[39m\u001b[39mEpoch \u001b[39m\u001b[39m{\u001b[39;00mt\u001b[39m+\u001b[39m\u001b[39m1\u001b[39m\u001b[39m}\u001b[39;00m\u001b[39m\\n\u001b[39;00m\u001b[39m-------------------------------\u001b[39m\u001b[39m\"\u001b[39m)\n\u001b[1;32m----> 3\u001b[0m     train_loop(dataloader, model, loss_function, optimizer)\n\u001b[0;32m      4\u001b[0m \u001b[39mprint\u001b[39m(\u001b[39m\"\u001b[39m\u001b[39mDone!\u001b[39m\u001b[39m\"\u001b[39m)\n",
      "Cell \u001b[1;32mIn [29], line 17\u001b[0m, in \u001b[0;36mtrain_loop\u001b[1;34m(dataloader, model, loss_function, optimizer)\u001b[0m\n\u001b[0;32m     15\u001b[0m \u001b[39m# Backpropagation\u001b[39;00m\n\u001b[0;32m     16\u001b[0m optimizer\u001b[39m.\u001b[39mzero_grad()\n\u001b[1;32m---> 17\u001b[0m loss\u001b[39m.\u001b[39;49mbackward()\n\u001b[0;32m     18\u001b[0m optimizer\u001b[39m.\u001b[39mstep()\n\u001b[0;32m     20\u001b[0m \u001b[39mif\u001b[39;00m batch \u001b[39m%\u001b[39m \u001b[39m100\u001b[39m \u001b[39m==\u001b[39m \u001b[39m0\u001b[39m:\n",
      "File \u001b[1;32mc:\\Users\\s1612415\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\torch\\_tensor.py:487\u001b[0m, in \u001b[0;36mTensor.backward\u001b[1;34m(self, gradient, retain_graph, create_graph, inputs)\u001b[0m\n\u001b[0;32m    477\u001b[0m \u001b[39mif\u001b[39;00m has_torch_function_unary(\u001b[39mself\u001b[39m):\n\u001b[0;32m    478\u001b[0m     \u001b[39mreturn\u001b[39;00m handle_torch_function(\n\u001b[0;32m    479\u001b[0m         Tensor\u001b[39m.\u001b[39mbackward,\n\u001b[0;32m    480\u001b[0m         (\u001b[39mself\u001b[39m,),\n\u001b[1;32m   (...)\u001b[0m\n\u001b[0;32m    485\u001b[0m         inputs\u001b[39m=\u001b[39minputs,\n\u001b[0;32m    486\u001b[0m     )\n\u001b[1;32m--> 487\u001b[0m torch\u001b[39m.\u001b[39;49mautograd\u001b[39m.\u001b[39;49mbackward(\n\u001b[0;32m    488\u001b[0m     \u001b[39mself\u001b[39;49m, gradient, retain_graph, create_graph, inputs\u001b[39m=\u001b[39;49minputs\n\u001b[0;32m    489\u001b[0m )\n",
      "File \u001b[1;32mc:\\Users\\s1612415\\AppData\\Local\\Programs\\Python\\Python310\\lib\\site-packages\\torch\\autograd\\__init__.py:197\u001b[0m, in \u001b[0;36mbackward\u001b[1;34m(tensors, grad_tensors, retain_graph, create_graph, grad_variables, inputs)\u001b[0m\n\u001b[0;32m    192\u001b[0m     retain_graph \u001b[39m=\u001b[39m create_graph\n\u001b[0;32m    194\u001b[0m \u001b[39m# The reason we repeat same the comment below is that\u001b[39;00m\n\u001b[0;32m    195\u001b[0m \u001b[39m# some Python versions print out the first line of a multi-line function\u001b[39;00m\n\u001b[0;32m    196\u001b[0m \u001b[39m# calls in the traceback and some print out the last line\u001b[39;00m\n\u001b[1;32m--> 197\u001b[0m Variable\u001b[39m.\u001b[39;49m_execution_engine\u001b[39m.\u001b[39;49mrun_backward(  \u001b[39m# Calls into the C++ engine to run the backward pass\u001b[39;49;00m\n\u001b[0;32m    198\u001b[0m     tensors, grad_tensors_, retain_graph, create_graph, inputs,\n\u001b[0;32m    199\u001b[0m     allow_unreachable\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m, accumulate_grad\u001b[39m=\u001b[39;49m\u001b[39mTrue\u001b[39;49;00m)\n",
      "\u001b[1;31mRuntimeError\u001b[0m: Trying to backward through the graph a second time (or directly access saved tensors after they have already been freed). Saved intermediate values of the graph are freed when you call .backward() or autograd.grad(). Specify retain_graph=True if you need to backward through the graph a second time or if you need to access saved tensors after calling backward."
     ]
    }
   ],
   "source": [
    "for t in range(epochs):\n",
    "    print(f\"Epoch {t+1}\\n-------------------------------\")\n",
    "    train_loop(dataloader, model, loss_function, optimizer)\n",
    "print(\"Done!\")"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Test"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Test 0\n",
    "plt.scatter(t_test, x0_test, alpha=0.5)\n",
    "plt.scatter(t_test, model(torch.cat((k0_vec, m0_vec, x00_vec, v00_vec, t_test), 1)).detach())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Test 1\n",
    "plt.scatter(t_test, x1_test, alpha=0.5)\n",
    "plt.scatter(t_test, model(torch.cat((k1_vec, m1_vec, x01_vec, v01_vec, t_test), 1)).detach())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "## Test 2\n",
    "plt.scatter(t_test, x2_test, alpha=0.5)\n",
    "plt.scatter(t_test, model(torch.cat((k2_vec, m2_vec, x02_vec, v02_vec, t_test), 1)).detach())\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.8"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "9b3b15e79d64212a14c381e1bc9a41101994b32312634469deb1a16fd6054240"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}
